/**
 * 任务状态管理API - 后台管理
 * 提供任务状态的查询和管理功能
 */

const Framework = require("../../framework/node-core-framework.js");

module.exports = {
  /**
   * @swagger
   * /admin_api/task/commands:
   *   post:
   *     summary: 获取任务的指令列表
   *     description: 获取指定任务的所有指令记录
   *     tags: [后台-任务管理]
   *     requestBody:
   *       required: true
   *       content:
   *         application/json:
   *           schema:
   *             type: object
   *             properties:
   *               taskId:
   *                 type: integer
   *                 description: 任务ID
   *     responses:
   *       200:
   *         description: 获取成功
   */
  'POST /task/commands': async (ctx) => {
    const models = Framework.getModels();
    const { task_commands, op } = models;
    const { taskId } = ctx.getBody();

    if (!taskId) {
      return ctx.error('任务ID不能为空');
    }

    // 查询该任务的所有指令，按执行顺序排序
    const commands = await task_commands.findAll({
      where: { task_id: taskId },
      order: [
        ['sequence', 'ASC'],
        ['create_time', 'ASC']
      ]
    });

    return ctx.success(commands);
  },

  /**
   * @swagger
   * /admin_api/task/list:
   *   post:
   *     summary: 获取任务列表
   *     description: 分页获取所有任务状态
   *     tags: [后台-任务管理]
   *     requestBody:
   *       required: true
   *       content:
   *         application/json:
   *           schema:
   *             type: object
   *             properties:
   *               page:
   *                 type: integer
   *                 description: 页码
   *               pageSize:
   *                 type: integer
   *                 description: 每页数量
   *               taskType:
   *                 type: string
   *                 description: 任务类型(可选)
   *               status:
   *                 type: string
   *                 description: 任务状态(可选)
   *     responses:
   *       200:
   *         description: 获取成功
   */
  'POST /task/list': async (ctx) => {
    const models = Framework.getModels();
    const { task_status, op } = models;
    const body = ctx.getBody();
    const { taskType, status, taskName, taskId, sn_code } = ctx.getBody();
    
    // 获取分页参数
    const { limit, offset } = ctx.getPageSize();

    
const where = {};
if (taskType) where.taskType = taskType;
if (status) where.status = status;

// 支持多种搜索字段
if (taskName) {
  where.taskName = { [op.like]: `%${taskName}%` };
}
if (taskId) {
  where.taskId = { [op.like]: `%${taskId}%` };
}
if (sn_code) {
  where.sn_code = { [op.like]: `%${sn_code}%` };
}

const result = await task_status.findAndCountAll({
  where,
  limit,
  offset,
  order: [
    ['status', 'ASC'],
    ['startTime', 'DESC']
  ]
});

return ctx.success({
  count: result.count,
  rows: result.rows
});
    
  },

  /**
   * @swagger
   * /admin_api/task/statistics:
   *   get:
   *     summary: 获取任务统计
   *     description: 获取任务状态的统计数据
   *     tags: [后台-任务管理]
   *     responses:
   *       200:
   *         description: 获取成功
   */
  'GET /task/statistics': async (ctx) => {
    const models = Framework.getModels();
    const { task_status } = models;

    
const [
  totalTasks,
  runningTasks,
  completedTasks,
  failedTasks,
  pausedTasks
] = await Promise.all([
  task_status.count(),
  task_status.count({ where: { status: 'running' } }),
  task_status.count({ where: { status: 'completed' } }),
  task_status.count({ where: { status: 'failed' } }),
  task_status.count({ where: { status: 'paused' } })
]);

// 按任务类型统计
const typeStats = await task_status.findAll({
  attributes: [
    'taskType',
    [models.sequelize.fn('COUNT', models.sequelize.col('*')), 'count']
  ],
  group: ['taskType'],
  raw: true
});

// 按状态统计
const statusStats = await task_status.findAll({
  attributes: [
    'status',
    [models.sequelize.fn('COUNT', models.sequelize.col('*')), 'count']
  ],
  group: ['status'],
  raw: true
});

// 计算成功率
const successRate = totalTasks > 0 ? ((completedTasks / totalTasks) * 100).toFixed(2) : 0;

return ctx.success({
  totalTasks,
  runningTasks,
  completedTasks,
  failedTasks,
  pausedTasks,
  successRate,
  typeStats,
  statusStats
});
    
  },

  /**
   * @swagger
   * /admin_api/task/detail:
   *   get:
   *     summary: 获取任务详情
   *     description: 根据任务ID获取详细信息
   *     tags: [后台-任务管理]
   *     parameters:
   *       - in: query
   *         name: taskId
   *         required: true
   *         schema:
   *           type: string
   *         description: 任务ID
   *     responses:
   *       200:
   *         description: 获取成功
   */
  'GET /task/detail': async (ctx) => {
    const models = Framework.getModels();
    const { task_status } = models;
    const { taskId } = ctx.query;

    if (!taskId) {
      return ctx.fail('任务ID不能为空');
    }

    
const task = await task_status.findOne({ where: { taskId } });

if (!task) {
  return ctx.fail('任务不存在');
}

return ctx.success(task);
    
  },

  /**
   * @swagger
   * /admin_api/task/update:
   *   post:
   *     summary: 更新任务状态
   *     description: 更新任务的状态或进度
   *     tags: [后台-任务管理]
   *     requestBody:
   *       required: true
   *       content:
   *         application/json:
   *           schema:
   *             type: object
   *             required:
   *               - taskId
   *             properties:
   *               taskId:
   *                 type: string
   *                 description: 任务ID
   *               status:
   *                 type: string
   *                 description: 任务状态
   *     responses:
   *       200:
   *         description: 更新成功
   */
  'POST /task/update': async (ctx) => {
    const models = Framework.getModels();
    const { task_status } = models;
    const body = ctx.getBody();
    const { taskId, status, progress, errorMessage } = body;

    if (!taskId) {
      return ctx.fail('任务ID不能为空');
    }

    
const updateData = {

};

if (status) {
  updateData.status = status;
  if (status === 'completed') {
    updateData.endTime = new Date();
    updateData.progress = 100;
  } else if (status === 'failed') {
    updateData.endTime = new Date();
  }
}
if (progress !== undefined) updateData.progress = progress;
if (errorMessage) updateData.errorMessage = errorMessage;

await task_status.update(updateData, { where: { taskId } });

return ctx.success({ message: '任务状态更新成功' });
    
  },

  /**
   * @swagger
   * /admin_api/task/delete:
   *   post:
   *     summary: 删除任务
   *     description: 删除指定的任务记录
   *     tags: [后台-任务管理]
   *     requestBody:
   *       required: true
   *       content:
   *         application/json:
   *           schema:
   *             type: object
   *             required:
   *               - taskId
   *             properties:
   *               taskId:
   *                 type: string
   *                 description: 任务ID
   *     responses:
   *       200:
   *         description: 删除成功
   */
  'POST /task/delete': async (ctx) => {
    const models = Framework.getModels();
    const { task_status } = models;
    const body = ctx.getBody();
    const { taskId } = body;

    if (!taskId) {
      return ctx.fail('任务ID不能为空');
    }

    
const result = await task_status.destroy({ where: { taskId } });

if (result === 0) {
  return ctx.fail('任务不存在');
}

return ctx.success({ message: '任务删除成功' });
    
  },

  /**
   * @swagger
   * /admin_api/task/cancel:
   *   post:
   *     summary: 取消任务
   *     description: 取消正在执行或待执行的任务
   *     tags: [后台-任务管理]
   *     requestBody:
   *       required: true
   *       content:
   *         application/json:
   *           schema:
   *             type: object
   *             required:
   *               - taskId
   *             properties:
   *               taskId:
   *                 type: string
   *                 description: 任务ID
   *     responses:
   *       200:
   *         description: 取消成功
   */
  'POST /task/cancel': async (ctx) => {
    const models = Framework.getModels();
    const { task_status } = models;
    const body = ctx.getBody();
    const { taskId } = body;

    if (!taskId) {
      return ctx.fail('任务ID不能为空');
    }

    const task = await task_status.findOne({ where: { taskId } });
    
    if (!task) {
      return ctx.fail('任务不存在');
    }

    if (task.status !== 'pending' && task.status !== 'running') {
      return ctx.fail('只能取消待执行或执行中的任务');
    }

    await task_status.update({
      status: 'cancelled',
      endTime: new Date(),
    }, { where: { taskId } });

    return ctx.success({ message: '任务取消成功' });
  },

  /**
   * @swagger
   * /admin_api/task/retry:
   *   post:
   *     summary: 重试任务
   *     description: 重新执行失败的任务
   *     tags: [后台-任务管理]
   *     requestBody:
   *       required: true
   *       content:
   *         application/json:
   *           schema:
   *             type: object
   *             required:
   *               - taskId
   *             properties:
   *               taskId:
   *                 type: string
   *                 description: 任务ID
   *     responses:
   *       200:
   *         description: 重试成功
   */
  'POST /task/retry': async (ctx) => {
    const models = Framework.getModels();
    const { task_status } = models;
    const body = ctx.getBody();
    const { id } = body;

    if (!id) {
      return ctx.fail('任务ID不能为空');
    }

    const task = await task_status.findOne({ where: { id } });
    
    if (!task) {
      return ctx.fail('任务不存在');
    }

    if (task.status !== 'failed') {
      return ctx.fail('只能重试失败的任务');
    }

    await task_status.update({
      status: 'pending',
      progress: 0,
      errorMessage: '',
      errorStack: '',
      startTime: null,
      endTime: null
    }, { where: { id } });

    return ctx.success({ message: '任务重试成功' });
  },

  /**
   * @swagger
   * /admin_api/task/export:
   *   post:
   *     summary: 导出任务列表
   *     description: 导出任务列表为CSV文件
   *     tags: [后台-任务管理]
   *     requestBody:
   *       required: true
   *       content:
   *         application/json:
   *           schema:
   *             type: object
   *             properties:
   *               taskType:
   *                 type: string
   *                 description: 任务类型(可选)
   *               status:
   *                 type: string
   *                 description: 任务状态(可选)
   *     responses:
   *       200:
   *         description: 导出成功
   */
  'POST /task/export': async (ctx) => {
    const models = Framework.getModels();
    const { task_status, op } = models;
    const body = ctx.getBody();
    const { taskType, status, taskName, id, sn_code } = body;

    const where = {};
    if (taskType) where.taskType = taskType;
    if (status) where.status = status;
    if (taskName) where.taskName = { [op.like]: `%${taskName}%` };
    if (id) where.id = id;
    if (sn_code) where.sn_code = { [op.like]: `%${sn_code}%` };

    const tasks = await task_status.findAll({
      where,
      order: [
        ['status', 'ASC'],
        ['startTime', 'DESC']
      ]
    });

    // 生成CSV内容
    const headers = ['任务ID', '设备SN码', '任务类型', '任务名称', '任务状态', '进度', '开始时间', '结束时间', '创建时间', '错误信息'];
    const rows = tasks.map(task => [
      task.id,
      task.sn_code,
      task.taskType,
      task.taskName || '',
      task.status,
      task.progress || 0,
      task.startTime || '',
      task.endTime || '',
      task.errorMessage || ''
    ]);

    let csv = headers.join(',') + '\n';
    csv += rows.map(row => row.map(cell => `"${String(cell).replace(/"/g, '""')}"`).join(','))
      .join('\n');

    // 添加 BOM 以支持 Excel 正确识别 UTF-8
    const bom = '\uFEFF';
    const content = bom + csv;

    ctx.set('Content-Type', 'text/csv; charset=utf-8');
    ctx.set('Content-Disposition', `attachment; filename="tasks_${Date.now()}.csv"`);
    
    return ctx.success(content);
  }
};

